package com.centerm.structure.api;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.centerm.common.constant.Constant;
import com.centerm.common.constant.error.GlobalErrorEnum;
import com.centerm.common.constant.validate.Delete;
import com.centerm.common.constant.validate.Insert;
import com.centerm.common.constant.validate.Update;
import com.centerm.common.view.JSONResponse;
import com.centerm.common.view.page.DefaultPage;
import com.centerm.common.view.page.PageQueryParam;
import com.centerm.common.view.page.PageQueryResult;
import com.centerm.structure.dto.RoleInfo;
import com.centerm.structure.dto.RolePermissionInfo;
import com.centerm.structure.service.RolePermissionService;
import com.centerm.structure.service.RoleService;

@RestController
@RequestMapping("role")
public class RoleAPI extends AbstractAPI {
    @Autowired
    private RoleService roleService;
    @Autowired
    private RolePermissionService rolePermissionService;
    
    /**
     * 根据条件分页查询角色列表
     * @author czy
	 * @date 2017年8月14日
     * @param 
     * @return 
     */
    @PostMapping("page/byParam")
    public JSONResponse<PageQueryResult<RoleInfo>> pageRoleByParam(
            @RequestBody PageQueryParam<RoleInfo> param) {
        DefaultPage page = param.getPage();
        RoleInfo roleInfo = param.getParam();
        if(page == null || roleInfo == null) {
            // 参数检查异常
            logger.debug("PARAM_ERROR：" + param.toString());
            return new JSONResponse<>(GlobalErrorEnum.PARAM_ERROR);
        }
        // 分页查询
        PageQueryResult<RoleInfo> queryResult = roleService.pageRoleInfoList(
                page.getPageNum() == null ? Constant.DEFAULT_PAGENUM : page.getPageNum(), 
                        page.getPageSize() == null ? Constant.DEFAULT_PAGESIZE : page.getPageSize(),
                        		roleInfo);
        return success(queryResult);
    }
    
    /**
     * 新增角色信息
     * @author czy
	 * @date 2017年8月11日
     * @param RoleInfo:角色信息
     * @return 角色id
     */
    @PostMapping("insert")
    public JSONResponse<Integer> insert(@RequestBody @Validated(Insert.class) RoleInfo roleInfo) {
        Integer result = roleService.insert(roleInfo);
        if (result == null||result < 1) {
			logger.error("新增角色异常：" + GlobalErrorEnum.UNKNOWN_ERROR.getMsg());
			return new JSONResponse<>(GlobalErrorEnum.UNKNOWN_ERROR);
		} else {
			return success(result);
		}
    }
    
	/**
	* @Description: 
	* 	更新角色信息
	* @author czy
	* @date 2017年8月11日
	* @param RoleInfo 角色信息
	* @return JSONResponse<Integer>
	 */
	@PostMapping("update")
	public JSONResponse<Integer> update(@RequestBody @Validated(Update.class) RoleInfo roleRequest) {
		Integer result = roleService.update(roleRequest);
		if (result != 1) {
			logger.error("更新角色异常：" + GlobalErrorEnum.UNKNOWN_ERROR.getMsg());
			return new JSONResponse<>(GlobalErrorEnum.UNKNOWN_ERROR);
		} else {
			return success(result);
		}
	}
	
	/**
	* @Description: 
	* 	物理删除角色
	* @author czy
	* @date 2017年7月26日
	* @param id 角色id
	* @return JSONResponse<Integer>
	 */
	@PostMapping("delete/physic")
	public JSONResponse<Integer> deletePhysic(@RequestBody @Validated(Delete.class) RoleInfo roleRequest) {
		Integer result = roleService.delete(roleRequest.getId());
		if (result != 1) {
			logger.error("物理删除角色异常：" + GlobalErrorEnum.UNKNOWN_ERROR.getMsg());
			return new JSONResponse<>(GlobalErrorEnum.UNKNOWN_ERROR);
		} else {
			return success(result);
		}
	}
	
	/**
	* @Description: 
	* 	逻辑删除角色
	* @author czy
	* @date 2017年7月26日
	* @param id 角色id
	* @return JSONResponse<Integer>
	 */
	@PostMapping("delete/logic")
	public JSONResponse<Integer> deleteLogic(@RequestBody @Validated(Delete.class) RoleInfo roleRequest) {
		roleRequest.setValid(0);
		Integer result = roleService.update(roleRequest);
		if (result != 1) {
			logger.error("逻辑删除角色异常：" + GlobalErrorEnum.UNKNOWN_ERROR.getMsg());
			return new JSONResponse<>(GlobalErrorEnum.UNKNOWN_ERROR);
		} else {
			return success(result);
		}
	}
	
	/**
	 * @Description: 
	 *   根据id获取角色详细信息
	 * @author czy
	 * @date 2017年8月11日
	 * @param id 角色id
	 * @return RoleInfo
	 */
	@PostMapping("getById")
	public JSONResponse<RoleInfo> getById(@RequestBody RoleInfo roleInfo) {
		Integer roleId = roleInfo.getId();
		if (roleId == null) {
			logger.error("获取角色详细信息异常：" + GlobalErrorEnum.PARAM_ERROR.getMsg());
			return new JSONResponse<>(GlobalErrorEnum.PARAM_ERROR);
		}
		roleInfo = roleService.getById(roleId);
		if (roleInfo == null) {
			logger.error("获取角色详细信息异常：" + GlobalErrorEnum.UNKNOWN_ERROR.getMsg());
			return new JSONResponse<>(GlobalErrorEnum.UNKNOWN_ERROR);
		} else {
			return success(roleInfo);
		}
	}
	
	/**
	 * @Description: 
	 *   更新角色权限
	 * @author czy
	 * @date 2017年8月17日
	 * @param id 角色id
	 * @return Integer
	 */
	@PostMapping("role/rolePermission")
	public JSONResponse<Integer> updateUserRole(@RequestBody RolePermissionInfo rolePermissionInfo) {
		if(rolePermissionInfo.getRoleId()==null){
			logger.error("同步角色权限信息异常：" + GlobalErrorEnum.PARAM_ERROR.getMsg());
			return new JSONResponse<>(GlobalErrorEnum.PARAM_ERROR);
		}
		Integer result = rolePermissionService.update(rolePermissionInfo);
		return success(result);
		
	}
}
